package com.ruoyi.web.controller.grade;


import com.ruoyi.common.annotation.Anonymous;
import com.ruoyi.common.core.controller.BaseController;
import com.ruoyi.common.core.domain.R;
import com.ruoyi.common.utils.SecurityUtils;
import com.ruoyi.grade.domain.TotalGradeRankMoudle;
import com.ruoyi.grade.domain.entity.MsUser;
import com.ruoyi.grade.domain.entity.MsUserRole;
import com.ruoyi.grade.domain.entity.Student;
import com.ruoyi.grade.service.IAdminService;
import com.ruoyi.grade.service.IMsUserRoleService;
import com.ruoyi.grade.service.IMsUserService;
import com.ruoyi.grade.service.IStudentService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiImplicitParams;
import io.swagger.annotations.ApiOperation;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@RestController
@RequestMapping("/admin")
@CrossOrigin
public class AdminController extends BaseController {

    @Autowired
    private IAdminService adminService;

    @Autowired
    private IMsUserService userService;

    @Autowired
    private IMsUserRoleService userRoleService;

    @Autowired
    private IStudentService studentService;
    /**
     * 获取所有学生的总成绩排名。
     *
     * @return 返回一个包含所有学生总成绩排名的响应对象 R。
     */
    @GetMapping("/getTotalStudentGradeRank")
    @PreAuthorize("@ss.hasPermi('admin:getTotalStudentGradeRank')")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "Authorization", value = "认证码", paramType = "header", required = true)
    })
    public R<List<TotalGradeRankMoudle>> getTotalStudentGradeRank(String userName){
        return R.ok(adminService.getTotalStudentGradeRank(userName));
    }

    /**
     * 获取某门课程的成绩排名。
     *
     * @param courseName 课程名称，用于指定需要查询的课程。
     * @return 返回一个包含该课程成绩排名的响应对象 R。
     */
    @GetMapping("/getSingleCourseGradeRank")
    @PreAuthorize("@ss.hasPermi('admin:getSingleCourseGradeRank')")
    public R getSingleCourseGradeRank(String userName, String courseName){
        return R.ok(adminService.getSingleCourseGradeRank(userName, courseName));
    }

    /**
     * 获取某个学生的总成绩排名。
     *
     * @param studentId 学生用户名，用于指定需要查询的学生。
     * @return 返回一个包含该学生总成绩排名的响应对象 R。
     */
    @GetMapping("/getOneTotalGradeRank")
    @PreAuthorize("@ss.hasPermi('admin:getOneTotalGradeRank')")
    public R getOneTotalGradeRank(String studentId){
        return R.ok(adminService.getOneTotalGradeRank(studentId));
    }

    /**
     * 获取某个学生在某门课程中的成绩排名。
     *
     * @param studentId 学生Id，用于指定需要查询的学生。
     * @param courseName 课程名称，用于指定需要查询的课程。
     * @return 返回一个包含该学生在该课程中成绩排名的响应对象 R。
     */
    @GetMapping("/getOneSingleGradeRank")
    @PreAuthorize("@ss.hasPermi('admin:getOneSingleGradeRank')")
    public R getOneSingleGradeRank(String studentId,String courseName){
        return R.ok(adminService.getOneSingleGradeRank(studentId,courseName));
    }

    /**
     * 删除某个学生的相关信息。
     *
     * @param studentId 学生ID，用于指定需要删除的学生。
     * @return 返回一个表示删除成功与否的响应对象 R。
     */
    @DeleteMapping("/deleteStudentMessage")
    @PreAuthorize("@ss.hasPermi('admin:deleteStudentMessage')")
    public R deleteStudentMessage(String studentId){
        return R.ok(adminService.deleteStudentMessage(studentId));
    }

    /**
     * 删除某个学年和学期的相关信息。
     *
     * @param academicYear 学年，用于指定需要删除的学年。
     * @param semester 学期，用于指定需要删除的学期。
     * @return 返回一个表示删除成功与否的响应对象 R。
     */
    @DeleteMapping("/deleteAcademicYearSemesterMessage")
    @PreAuthorize("@ss.hasPermi('admin:deleteAcademicYearSemesterMessage')")
    public R deleteAcademicYearSemesterMessage(String academicYear,String semester){
        return R.ok(adminService.deleteAcademicYearSemesterMessage(academicYear,semester));
    }

    /**
     * 添加学生信息。
     *
     * @param student 学生对象，包含需要添加的学生信息。
     * @return 返回一个表示添加成功与否的响应对象 R。
     */
    @PostMapping("/addStudentMessage")
    @PreAuthorize("@ss.hasPermi('admin:addStudentMessage')")
    public R addStudentMessage(@RequestBody Student student){
        //转为数据库对象
        MsUser user = new MsUser();
        user.setUserName(student.getStudentId());
        user.setNickName(student.getStudentId());
        user.setPassword(SecurityUtils.encryptPassword(student.getPassword()));
        user.setCreateBy(getUsername());

        //判断studentId是否存在
        if (!userService.checkUserNameExist(student.getStudentId())){
            //账号不存在
            //调用保存业务
            userService.save(user);
            studentService.save(new Student(user.getUserName(), SecurityUtils.encryptPassword(student.getPassword())));
            userRoleService.save(new MsUserRole(user.getUserId(), 100l));

            return R.ok("新增学生成功!");
        } else {
            //账号存在
            user.setUserId(userService.getUserIdByUserName(user.getUserName()));
            userService.updateById(user);
            if (studentService.checkStudentIdExist(user.getUserName())){
                studentService.updateById(new Student(user.getUserName(), SecurityUtils.encryptPassword(student.getPassword())));
            }
            return R.ok("修改学生密码成功");
        }
    }

    /**
     * 获取学生体测成绩。
     *
     * @param studentId 学生ID，用于指定需要查询的学生。
     * @param academicYear 学年，用于指定需要查询的学年。
     * @return 返回一个表示查询成功与否的响应对象 R。
     */
    @GetMapping("/getStudentPhysicalGrade")
    @PreAuthorize("@ss.hasPermi('admin:getAllStudentPhysicalGrade')")
    public R getAllStudentPhysicalGrade(String studentId,String academicYear){
        return R.ok(adminService.getStudentPhysicalGrade(studentId,academicYear));
    }

    /**
     * 根据专业获取全部学生总成绩排名
     * 此方法允许匿名访问，无需用户认证
     * 使用 GET 请求获取指定专业的所有学生的总成绩排名信息
     *
     * @param major 专业名称，用于筛选学生的专业
     * @return 返回包含学生总成绩排名的信息
     */
    @GetMapping("/getAllStudentTotalGradeByMajor")
    @PreAuthorize("@ss.hasPermi('admin:getAllStudentTotalGradeByMajor')")
    public R getAllStudentTotalGradeByMajor(String major){
        return R.ok(adminService.getAllStudentTotalGradeByMajor(major));
    }

}
